const fs = require('fs');
const path = require('path');

// copy文件
// function copyFiles(cpath) {
//     fs.stat(cpath,(err,stats)=>{
//         if(stats.isFile()) {  复制文件
//             var prefix = cpath.substring(0,cpath.lastIndexOf('.'));
//             var suffix = cpath.substring(cpath.lastIndexOf('.')+1);
//             console.log(extension);
//             fs.copyFile(cpath,prefix+'Copy.'+suffix,(err)=>{
//                 console.log(cpath+' 复制成功!');
//             });
//         }else if(stats.isDirectory()) {  复制目录及子文件
//             var newcpath = cpath+'Copy';
//             fs.access(newcpath,(err)=>{
//                 if(err) {
//                     fs.mkdir(newcpath,(err)=>{
//                         console.log(newcpath+'创建成功!');
//                         fs.readdir(cpath,(err,files)=>{
//                             if(files.length>0) {
//                                 files.forEach((item)=>{
//                                     console.log(item);
//                                     var newfilepath = path.join(cpath,item);
//                                     var newfilepath2 = path.join(newcpath,item);
//                                     copyFiles(newfilepath,newfilepath2);
//                                     fs.copyFile(newfilepath,newfilepath2,(err)=>{});
//                                 });
//                             }
//                         });
//                     });
//                 }else{
//                      fs.readdir(cpath,(err,files)=>{
//                          if(files.length>0) {
//                              files.forEach((item)=>{
//                                  console.log(item);
//                                  var newfilepath = path.join(cpath,item);
//                                  var newfilepath2 = path.join(newcpath,item);
//                                  copyFiles(newfilepath,newfilepath2);
//                                  fs.copyFile(newfilepath,newfilepath2,(err)=>{});
//                              });
//                          }
//                      });
//                 }
//             });
//         }
//     });
// }
//
//  copyFiles(newafile); 复制文件
// copyFiles(newapath);

var srcFilePath = path.join(__dirname, '..', 'newdir', 'newdir.json');
var tarFilePath = path.join(__dirname, '..', 'newdirCopy', 'newdir.json');
// 读取文件
function readFile() {
    fs.readFile(srcFilePath, 'utf8', (err, data) => {
        if (err) {
            console.log('读取失败!');
        } else {
            console.log(data);
            return data;
        }
    });
}

// readFile();

// 写入文件
function writeFile(tarFile, data, callback) {
    fs.writeFile(tarFile, data, 'utf8', (err) => {
        if (err) {
            console.log(tarFile + '文件写入错误!\r\n', err);
        } else {
            console.log(tarFile + '文件保存成功!');
            callback && callback();
        }
    });
}

// writeFile(readFile());

// 1. 异步复制文件 目录必须存在
function copyFile(srcFile, tarFile, callback) {
    fs.readFile(srcFile, 'utf8', (err, data) => {
        if (err) {
            console.log(srcFile + '文件读取异常!\r\n', err);
        } else {
            writeFile(tarFile, data, callback);
        }
    });
}

// 异步复制文件回掉
function copyFileCallback(err) {
    if (err) {
        return;
    }
}

// copyFile(srcFilePath, tarFilePath, copyFileCallback);


// console.log(process.argv.slice(2));

// 2.小文件同步拷贝
function copyFileSync(src, tar) {
    fs.writeFileSync(tar, fs.readFileSync(src, 'utf8'), 'utf8');
}

// copyFileSync(srcFilePath, tarFilePath);

// 3.大文件拷贝(数据流方式)
function copyFileStream(src, tar) {
    fs.createReadStream(src).pipe(fs.createWriteStream(tar));
}

// copyFileStream(srcFilePath,tarFilePath);



// 4.复制文件目录
function copyFolder(srcDir,tarDir,cb) {
    fs.readdir(srcDir, function(err, files) {

        // var count = 0;
        // var checkEnd = function() {
        //     ++count == files.length && cb && cb();
        // };
        // if (err) {
        //     checkEnd();
        //     return;
        // }

        // 1.循环子文件以及目录
        files.forEach(function(file) {
            var srcPath = path.join(srcDir, file); //源文件或者目录
            var tarPath = path.join(tarDir, file); //目标文件或者目录

            fs.stat(srcPath, function(err, stats) {
                // （1）.如果源文件是目录
                if (stats.isDirectory()) {
                    // 如果目标目录不存在则创建目录复制直接复制文件
                    fs.access(tarPath,function(err){
                        if(err){
                            // 创建目录
                            fs.mkdir(tarPath, function(err) {
                                console.log(tarPath+' 目录创建成功!');
                                if (err) {
                                    console.log(err);
                                    return;
                                }
                                // 递归调用
                                //copyFolder(srcPath, tarPath, checkEnd);
                                copyFolder(srcPath, tarPath);

                            });
                        }
                        //存在目录直接递归调用
                        copyFolder(srcPath, tarPath);
                    });

                } else { //（2）. 如果是文件就直接复制文件

                    // copyFile(srcPath, tarPath, checkEnd);
                    copyFile(srcPath, tarPath);
                }
            });
        });

        //为空时直接回调
        //files.length === 0 && cb && cb();

    });
}


var srcDirPath = path.join(__dirname, '..', 'newdir');
var tarDirPath = path.join(__dirname, '..', 'newdirCopy');

fs.access(tarDirPath,(err)=>{
    if(err) {
        fs.mkdir(tarDirPath,(err)=>{
            copyFolder(srcDirPath, tarDirPath, function(err) {
                if (err) {
                    return;
                }
                //continue
            });
        });
    }else{
        copyFolder(srcDirPath, tarDirPath, function(err) {
            if (err) {
                return;
            }
            //continue
        });
    }
});
